unsigned __bits(8) a[10];
unsigned __bits(8) b[10];
unsigned __out __bits(16) d;
void main() {
unsigned __bits(8) x[10];
unsigned i,del,xm=0,s=0;
for (i=0;i<10;i++) {
if (a[i]==0 || b[i]==0) {if (a[i]>0) del=a[i]; else del=b[i];}
else {del=a[i]; while ((a[i]%del)>0 || (b[i]%del)>0) del--;}
x[i]=del;
}
for (i=0;i<10;i++) xm+=x[i];
xm/=10;
for (i=0;i<10;i++) s+=(x[i]-xm)*(x[i]-xm);
s/=10;
d=s;
}

------------------------------------------------------------

unsigned __bits(8) a[10];
unsigned __bits(8) b[10];
unsigned __out __bits(16) d;
void main() {
unsigned __bits(8) x[8];
unsigned i,del,xm=0,s=0;
for (i=0;i<10;i++) {
if (a[i]==0 || b[i]==0) {if (a[i]>0) del=a[i]; else del=b[i];}
else {del=a[i]; while ((a[i]%del)>0 || (b[i]%del)>0) del--;}
x[i]=del;
}
for (i=0;i<10;i++) xm+=x[i];
xm/=10;
for (i=0;i<10;i++) s+=(x[i]-xm)*(x[i]-xm);
s/=10;
d=s;
}

------------------------------------------------------------

unsigned __bits(8) x[10]; // Input vector x
unsigned __bits(8) y[10]; // Input vector y
unsigned __out __bits(16) d; // Output variable for variance (Sn^2)

void main() {
unsigned __bits(8) gcd_values[10]; // Array for GCDs of pairs
unsigned __bits(16) sum = 0; // Sum of GCD values
unsigned __bits(16) mean; // Mean of GCD values
unsigned __bits(16) variance_sum = 0; // Sum of squared differences

// Calculate GCDs and compute the sum
for (int i = 0; i < 10; i++) {
unsigned __bits(8) a = x[i];
unsigned __bits(8) b = y[i];

// Compute GCD using Euclid's algorithm
while (b != 0) {
unsigned __bits(8) temp = b;
b = a % b;
a = temp;
}
gcd_values[i] = a; // GCD is stored in 'a'
sum += gcd_values[i];
}

// Calculate mean
mean = sum / 10;

// Calculate the variance sum
for (int i = 0; i < 10; i++) {
unsigned __bits(16) diff = gcd_values[i] - mean;
variance_sum += diff * diff;
}

// Calculate unbiased variance (Sn^2)
d = variance_sum / 10;
}

------------------------------------------------------------

unsigned __in __bits(8) x[10]; // Input vector x
unsigned __in __bits(8) y[10]; // Input vector y
unsigned __out __bits(16) d; // Output variable for variance (Sn^2)

void main() {
unsigned __bits(8) gcd_values[10]; // Array for GCDs of pairs
unsigned __bits(16) sum = 0; // Sum of GCD values
unsigned __bits(16) mean; // Mean of GCD values
unsigned __bits(16) variance_sum = 0; // Sum of squared differences

// Calculate GCDs and compute the sum
for (int i = 0; i < 10; i++) {
unsigned __bits(8) a = x[i];
unsigned __bits(8) b = y[i];

// Compute GCD using Euclid's algorithm
while (b != 0) {
unsigned __bits(8) temp = b;
b = a % b;
a = temp;
}
gcd_values[i] = a; // GCD is stored in 'a'
sum += gcd_values[i];
}

// Calculate mean
mean = sum / 10;

// Calculate the variance sum
for (int i = 0; i < 10; i++) {
unsigned __bits(16) diff = gcd_values[i] - mean;
variance_sum += diff * diff;
}

// Calculate unbiased variance (Sn^2)
d = variance_sum / 10;
}

------------------------------------------------------------

unsigned __in __bits(8) x[10]; // Input vector x
unsigned __in __bits(8) y[10]; // Input vector y
unsigned __out __bits(16) d; // Output variable for variance (Sn^2)

void main() {
unsigned __bits(8) gcd_values[10]; // Array for GCDs of pairs
unsigned __bits(16) sum = 0; // Sum of GCD values
unsigned __bits(16) mean; // Mean of GCD values
unsigned __bits(16) variance_sum = 0; // Sum of squared differences

// Function to compute GCD of two numbers
unsigned __bits(8) gcd(unsigned __bits(8) a, unsigned __bits(8) b) {
while (b != 0) {
unsigned __bits(8) temp = b;
b = a % b;
a = temp;
}
return a;
}

// Calculate GCD for each pair and compute the sum
for (int i = 0; i < 10; i++) {
gcd_values[i] = gcd(x[i], y[i]);
sum += gcd_values[i];
}

// Calculate mean
mean = sum / 10;

// Calculate the variance sum
for (int i = 0; i < 10; i++) {
unsigned __bits(16) diff = gcd_values[i] - mean;
variance_sum += diff * diff;
}

// Calculate unbiased variance (Sn^2)
d = variance_sum / 10;
}

------------------------------------------------------------

int __bits(8) x[10];
int __bits(8) y[10];
int __bits(8) gcd[10];
int __bits(16) sum;
int __bits(16) sum_sq;
int __bits(16) mean;
int __bits(16) var;
int __bits(16) d;
int __bits(8) i;

int gcd_func(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}

void main() {
for (i = 0; i < 10; i++) {
gcd[i] = gcd_func(x[i], y[i]);
}
sum = 0;
sum_sq = 0;
for (i = 0; i < 10; i++) {
sum += gcd[i];
sum_sq += gcd[i] * gcd[i];
}

mean = sum / 10;
var = (sum_sq - (sum * sum / 10)) / 10;

d = var;
}

------------------------------------------------------------

int __bits(8) x[10];
int __bits(8) y[10];
int __bits(8) gcd[10];
int __bits(16) sum;
int __bits(16) sum_sq;
int __bits(16) mean;
int __bits(16) var;
int __bits(16) d;
int __bits(8) i;

int gcd_func(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}

void main() {
for (i = 0; i < 10; i++) {
gcd[i] = gcd_func(x[i], y[i]);
}
sum = 0;
sum_sq = 0;
for (i = 0; i < 10; i++) {
sum += gcd[i];
sum_sq += gcd[i] * gcd[i];
}

mean = sum / 10;

var = (sum_sq / 10) - (mean * mean);

d = var;
}

------------------------------------------------------------

int __bits(8) x[10];
int __bits(8) y[10];
int __bits(8) gcd[10];
int __bits(16) sum;
int __bits(16) sum_sq;
int __bits(16) mean;
int __bits(16) var;
int __bits(8) i;


int gcd_func(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}

void main() {

for (i = 0; i < 10; i++) {
gcd[i] = gcd_func(x[i], y[i]);
}


sum = 0;
sum_sq = 0;
for (i = 0; i < 10; i++) {
sum += gcd[i];
sum_sq += gcd[i] * gcd[i];
}


mean = sum / 10;


var = (sum_sq / 10) - (mean * mean);


d = var;
}

------------------------------------------------------------

unsigned __bits(8) x[10];
unsigned __bits(8) y[10];
unsigned __bits(8) gcd[10];
unsigned __bits(16) sum;
unsigned __bits(16) mean;
unsigned __bits(16) variance;
unsigned __bits(16) d;

unsigned __bits(8) compute_gcd(unsigned __bits(8) a, unsigned __bits(8) b) {
while (b != 0) {
unsigned __bits(8) temp = b;
b = a % b;
a = temp;
}
return a;
}

void main() {
for(int i = 0; i < 10; i++) {
gcd[i] = compute_gcd(x[i], y[i]);
}

sum = 0;
for(int i = 0; i < 10; i++) {
sum += gcd[i];
}

mean = sum / 10;

variance = 0;
for(int i = 0; i < 10; i++) {
variance += (gcd[i] - mean) * (gcd[i] - mean);
}

d = variance / 10;
}

------------------------------------------------------------

int __bits(8) x[10];
int __bits(8) y[10];
int __bits(16) d;

void main() {
int __bits(16) gcd[10];
int __bits(16) sum = 0;
int __bits(16) mean;
int __bits(16) variance = 0;

for (int i = 0; i < 10; i++) {
int __bits(16) a = x[i];
int __bits(16) b = y[i];
while (b != 0) {
int __bits(16) temp = b;
b = a % b;
a = temp;
}
gcd[i] = a;
sum += gcd[i];
}

mean = sum / 10;

for (i = 0; i < 10; i++) {
int __bits(16) diff = gcd[i] - mean;
variance += diff * diff;
}

d = variance / 9;
}

------------------------------------------------------------

int __bits(8) x[10];
int __bits(8) y[10];
int __bits(16) d;

void main() {
int __bits(16) gcd[10];
int __bits(16) sum = 0;
int __bits(16) mean;
int __bits(16) variance = 0;

for (int i = 0; i < 10; i++) {
int __bits(16) a = x[i];
int __bits(16) b = y[i];
while (b != 0) {
int __bits(16) temp = b;
b = a % b;
a = temp;
}
gcd[i] = a;
sum += gcd[i];
}

mean = sum / 10;

for ( i = 0; i < 10; i++) {
int __bits(16) diff = gcd[i] - mean;
variance += diff * diff;
}

d = variance / 9;
}

------------------------------------------------------------

int __bits(8) x[10];
int __bits(8) y[10];
int __bits(16) d;

void main() {
int __bits(16) gcd[10];
int __bits(16) sum = 0;
int __bits(16) mean;
int __bits(16) variance = 0;

for (int i = 0; i < 10; i++) {
int __bits(16) a = x[i];
int __bits(16) b = y[i];
while (b != 0) {
int __bits(16) temp = b;
b = a % b;
a = temp;
}
gcd[i] = a;
sum += gcd[i];
}

mean = sum / 10;

for (i = 0; i < 10; i++) {
int __bits(16) diff = gcd[i] - mean;
variance += (diff * diff) / 9; // Ensure division happens here for each squared difference
}

d = variance;
}

------------------------------------------------------------

int __bits(8) a[10];
int __bits(8) b[10];
int __bits(16) d;

int gcd(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}

void main() {
int gcdArray[10];
int sum = 0;
for (int i = 0; i < 10; i++) {
gcdArray[i] = gcd(a[i], b[i]);
sum += gcdArray[i];
}

int mean = sum / 10;
int varianceSum = 0;
for (int j = 0; j < 10; j++) {
int diff = gcdArray[j] - mean;
varianceSum += diff * diff;
}

d = varianceSum / 9;
}

------------------------------------------------------------

int __bits(8) a[10];
int __bits(8) b[10];
int __bits(16) d;

int gcd(int x, int y) {
while (y != 0) {
int temp = y;
y = x % y;
x = temp;
}
return x;
}

void main() {
int gcdArray[10];
int sum = 0;
for (int i1 = 0; i1 < 10; i1++) {
gcdArray[i1] = gcd(a[i1], b[i1]);
sum += gcdArray[i1];
}

int mean = sum / 10;
int varianceSum = 0;
for (int i2 = 0; i2 < 10; i2++) {
int diff = gcdArray[i2] - mean;
varianceSum += diff * diff;
}

d = varianceSum / 9;
}

------------------------------------------------------------

int __bits(8) a[10];
int __bits(8) b[10];
int __bits(16) d;

int gcd(int x, int y) {
while (y != 0) {
int temp = y;
y = x % y;
x = temp;
}
return x;
}

void main() {
int gcdArray[10];
int sum = 0;
for (int i = 0; i < 10; i++) {
gcdArray[i] = gcd(a[i], b[i]);
sum += gcdArray[i];
}

int mean = sum / 10;
int varianceSum = 0;
for (int i = 0; i < 10; i++) {
int diff = gcdArray[i] - mean;
varianceSum += diff * diff;
}

d = varianceSum / 9;
}

------------------------------------------------------------

int __bits(8) x[10];
int __bits(8) y[10];
int __bits(16) d;
int __bits(8) gcd_results[10];

int __bits(16) gcd(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}

void main() {
int __bits(16) sum = 0;
int __bits(16) mean;
int __bits(16) variance_sum = 0;

for (int i = 0; i < 10; i++) {
gcd_results[i] = gcd(x[i], y[i]);
sum += gcd_results[i];
}

mean = sum / 10;

for (int i = 0; i < 10; i++) {
variance_sum += (gcd_results[i] - mean) * (gcd_results[i] - mean);
}

d = variance_sum / 10;
}

------------------------------------------------------------

unsigned __in __bits(1) in_0;
unsigned __in __bits(1) in_1;
unsigned __in __bits(1) in_2;

unsigned __out __bits(1) out_0;

void main(){
out_0 = ~( ~((~in_0 & in_1) ^ (in_2 | in_0)) ^ ~((~in_2 & in_1) ^ in_2)) | (in_0 & in_1 & in_2);
}

------------------------------------------------------------

unsigned __bits(8) x[10];
unsigned __bits(8) y[10];
unsigned __out __bits(16) d;

void main() {
unsigned __bits(8) mas[10];
unsigned i, j;
for (i = 0; i < 10; ++i) {
if (x[i] < y[i])
j = x[i];
else
j = y[i];
while (x[i]%j) != 0 || y[i]%j != 0)
--j;
mas[i] = j;
}
unsigned xx = 0;
for (i = 0; i < 10; ++i)
xx += mas[i];
xx /= 10;
unsigned sum = 0;
for (i = 0; i < 10; ++i)
sum += (mas[i]-xx)*(mas[i]-xx);
sum /= 10;
d = sum;
}

------------------------------------------------------------

char x[10];
char y[10];
unsigned __out __bits(16) d;

void main(){
char c[10];
char m = 0;
for (int i = 0; i < 10; i++){
char v = 1;
if (x[i] > y[i]){
while (v <= x[i]){
if (x[i]%v == 0 && y[i]%v == 0){
c[i] = v;
}
v++;
}
}
else{
while (v <= y[i]){
if (x[i]%v == 0 && y[i]%v == 0){
c[i] = v;
}
v++;
}
}
}
for (i = 0; i < 10; i++){
m = m + c[i];
}
m = m/10;
char a = 0;
for (i = 0; i < 10; i++){
a = a + ((c[i] - m)*(c[i] - m));
}
d = x/10;
}

------------------------------------------------------------

unsigned __bits(8) x[10];
unsigned __bits(8) y[10];
unsigned __out __bits(16) d;

void main() {
unsigned __bits(8) mas[10];
unsigned i, j;
for (i = 0; i < 10; ++i) {
if (x[i] < y[i])
j = x[i];
else
j = y[i];
while (x[i]%j != 0 && y[i]%j != 0) --j;
mas[i] = j;
}
unsigned xx = 0;
for (i = 0; i < 10; ++i)
xx += mas[i];
xx /= 10;
unsigned sum = 0;
for (i = 0; i < 10; ++i)
sum += (mas[i]-xx)*(mas[i]-xx);
sum /= 10;
d = sum;
}

------------------------------------------------------------

char x[10];
char y[10];
unsigned __out __bits(16) d;

void main(){
char c[10];
for (int i = 0; i < 10; i++){
char v = 0;
if (x[i] > y[i]){
while (v < x[i]){
if (x[i]%v == 0 && y[i]%v == 0){
c[i] = v;
}
}
}
else{
while (v < y[i]){
if (x[i]%v == 0 && y[i]%v == 0){
c[i] = v;
}
}
}
}
char m = 0;
for (i = 0; i < 10; i++){
m = m + c[i];
}
m = m/10;
char a = 0;
for (i = 0; i < 10; i++){
a = a + ((c[i] - m)*(c[i] - m));
}
x = x/10;
d = x;
}

------------------------------------------------------------

char a[10];
char b[10];
unsigned __out __bits(16) d;

void main(){
char c[10];
for (int i = 0; i < 10; i++){
char v = 0;
if (a[i] > b[i]){
while (v < a[i]){
if (a[i]%v == 0 && b[i]%v == 0){
c[i] = v;
}
}
}
else{
while (v < b[i]){
if (a[i]%v == 0 && b[i]%v == 0){
c[i] = v;
}
}
}
}
char m = 0;
for (i = 0; i < 10; i++){
m = m + c[i];
}
m = m/10;
char x = 0;
for (i = 0; i < 10; i++){
x = x + ((c[i] - m)*(c[i] - m));
}
x = x/10;
d = x;
}

------------------------------------------------------------

unsigned __bits(8) x[10];
unsigned __bits(8) y[10];
unsigned __out __bits(16)d;


unsigned Nod(unsigned a, unsigned b)
{
unsigned min = a;
if(min > b)
min = b;
unsigned i1;
unsigned nod = 1;
for(i1 = 1; i1 <= min; i1++)
{
if(((a%i1)==0)&&((b%i1)==0))
nod = i1;
}
return nod;
}


void main()
{
unsigned __bits(8) z[10];
unsigned __bits(8) x1;
unsigned __bits(8) y1;
unsigned __bits(8) z1;
int i;
for(i = 0; i < 10;i++)
{
x1 = x[i];
y1 = y[i];
z1 = Nod(x1,y1);
z[i] = z1;
}
unsigned __bits(8) sr;
unsigned __bits(8) sum = 0;
for(i = 0; i< 10; i++)
sum = sum + z[i];
sr = sum/10;

unsigned __bits(8) s = 0;
for(i = 0; i < 10 ;i++)
{
z1 = z[i];
s =s + (z1 - sr)*(z1 - sr);
}
s = s/10;

d = s;
}

------------------------------------------------------------

int __bits(8) x[10];
int __bits(8) y[10];
int __bits(16) d;



void main(){
int res = 0;
for(int i = 0;i < 10;i++){
if((x[i] - y[i]) < 0)
res += (-1)*(x[i] - y[i]);
else
res += (x[i] - y[i]);
}
d = res / 10;
}

------------------------------------------------------------

int __bits(8) x[10];
int __bits(8) y[10];
int __bits(16) d;



void main(){
int res = 0;
for(int i = 0;i < 10;i++){
if((x[i] - y[i]) < 0)
res = (-1)*(x[i] - y[i]);
else
res = (x[i] - y[i]);
}
d = res / 10;
}

------------------------------------------------------------

int x[10];
int y[10];
int __bits(16) d;



void main(){
int res = 0;
for(int i = 0;i < 10;i++){
if((x[i] - y[i]) < 0)
res = (-1)*(x[i] - y[i]);
else
res = (x[i] - y[i]);
}
d = res / 10;
}